juce/source/extras/the jucer/src/ui/jucer_ComponentOverlayComponent.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-11 by Raw Material Software Ltd.
   6
   7   ------------------------------------------------------------------------------
   8
   9    JUCE can be redistributed and/or modified under the terms of the GNU General
  10    Public License (Version 2), as published by the Free Software Foundation.
  11    A copy of the license is included in the JUCE distribution, or can be found
  12    online at www.gnu.org/licenses.
  13
  14    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY
  15    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  16    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
  17
  18   ------------------------------------------------------------------------------
  19
  20    To release a closed-source product which uses JUCE, commercial licenses are
  21    available: visit www.rawmaterialsoftware.com/juce for more information.
  22
  23   ==============================================================================
  24 */
  25
  26 #include "../jucer_Headers.h"
  27 #include "jucer_ComponentLayoutEditor.h"
  28
  29
  30 //==============================================================================
  31 ComponentOverlayComponent::ComponentOverlayComponent (Component* const target_,
  32                                                       ComponentLayout& layout_)
  33     : target (target_),
  34       borderThickness (4),
  35       layout (layout_),
  36       selected (false),
  37       dragging (false),
  38       originalAspectRatio (1.0)
  39 {
  40     setMinimumOnscreenAmounts (0, 0, 0, 0);
  41     setSizeLimits (borderThickness * 2 + 2, borderThickness * 2 + 2, 8192, 8192);
  42
  43     addChildComponent (border = new ResizableBorderComponent (this, this));
  44
  45     border->setBorderThickness (BorderSize<int> (borderThickness));
  46
  47     target->addComponentListener (this);
  48
  49     changeListenerCallback (0);
  50     layout.getSelectedSet().addChangeListener (this);
  51
  52     setRepaintsOnMouseActivity (true);
  53     border->setRepaintsOnMouseActivity (true);
  54 }
  55
  56 ComponentOverlayComponent::~ComponentOverlayComponent()
  57 {
  58     layout.getSelectedSet().removeChangeListener (this);
  59
  60     if (target != 0)
  61         target->removeComponentListener (this);
  62
  63     delete border;
  64 }
  65
  66 void ComponentOverlayComponent::changeListenerCallback (ChangeBroadcaster*)
  67 {
  68     const bool nowSelected = layout.getSelectedSet().isSelected (target);
  69
  70     if (selected != nowSelected)
  71     {
  72         selected = nowSelected;
  73         border->setVisible (nowSelected);
  74         repaint();
  75     }
  76 }
  77
  78 void ComponentOverlayComponent::paint (Graphics& g)
  79 {
  80     jassert (target != 0);
  81
  82     if (selected)
  83     {
  84         const BorderSize<int> borderSize (border->getBorderThickness());
  85
  86         drawResizableBorder (g, getWidth(), getHeight(), borderSize, (isMouseOverOrDragging() || border->isMouseOverOrDragging()));
  87     }
  88     else if (isMouseOverOrDragging())
  89     {
  90         drawMouseOverCorners (g, getWidth(), getHeight());
  91     }
  92 }
  93
  94 void ComponentOverlayComponent::resized()
  95 {
  96     jassert (target != 0);
  97
  98     border->setBounds (0, 0, getWidth(), getHeight());
  99 }
 100
 101 void ComponentOverlayComponent::mouseDown (const MouseEvent& e)
 102 {
 103     dragging = false;
 104     mouseDownSelectStatus = layout.getSelectedSet().addToSelectionOnMouseDown (target, e.mods);
 105
 106     if (e.mods.isPopupMenu())
 107     {
 108         showPopupMenu();
 109         return; // this may be deleted now..
 110     }
 111 }
 112
 113 void ComponentOverlayComponent::mouseDrag (const MouseEvent& e)
 114 {
 115     if (! e.mods.isPopupMenu())
 116     {
 117         if (selected && ! dragging)
 118         {
 119             dragging = ! e.mouseWasClicked();
 120
 121             if (dragging)
 122                 layout.startDragging();
 123         }
 124
 125         if (dragging)
 126         {
 127             layout.dragSelectedComps (e.getDistanceFromDragStartX(),
 128                                       e.getDistanceFromDragStartY());
 129         }
 130     }
 131 }
 132
 133 void ComponentOverlayComponent::mouseUp (const MouseEvent& e)
 134 {
 135     if (dragging)
 136         layout.endDragging();
 137
 138     layout.getSelectedSet().addToSelectionOnMouseUp (target, e.mods, dragging, mouseDownSelectStatus);
 139 }
 140
 141 void ComponentOverlayComponent::componentMovedOrResized (Component& component, bool wasMoved, bool wasResized)
 142 {
 143     updateBoundsToMatchTarget();
 144 }
 145
 146 void ComponentOverlayComponent::updateBoundsToMatchTarget()
 147 {
 148     Component* const parent = target->getParentComponent();
 149     jassert (parent != 0);
 150
 151     if (parent != 0)
 152     {
 153         const int dx = parent->getX();
 154         const int dy = parent->getY();
 155
 156         setBounds (dx + target->getX() - borderThickness,
 157                    dy + target->getY() - borderThickness,
 158                    target->getWidth() + borderThickness * 2,
 159                    target->getHeight() + borderThickness * 2);
 160     }
 161
 162     if (border->isMouseButtonDown())
 163         layout.changed();
 164 }
 165
 166 void ComponentOverlayComponent::resizeStart()
 167 {
 168     if (getHeight() > 0)
 169         originalAspectRatio = getWidth() / (double) getHeight();
 170     else
 171         originalAspectRatio = 1.0;
 172
 173     layout.getDocument()->getUndoManager().beginNewTransaction ("Resize components");
 174 }
 175
 176 void ComponentOverlayComponent::resizeEnd()
 177 {
 178     layout.getDocument()->getUndoManager().beginNewTransaction();
 179 }
 180
 181 void ComponentOverlayComponent::checkBounds (Rectangle<int>& bounds,
 182                                              const Rectangle<int>& previousBounds,
 183                                              const Rectangle<int>& limits,
 184                                              const bool isStretchingTop,
 185                                              const bool isStretchingLeft,
 186                                              const bool isStretchingBottom,
 187                                              const bool isStretchingRight)
 188 {
 189     if (ModifierKeys::getCurrentModifiers().isShiftDown())
 190         setFixedAspectRatio (originalAspectRatio);
 191     else
 192         setFixedAspectRatio (0.0);
 193
 194     ComponentBoundsConstrainer::checkBounds (bounds, previousBounds, limits, isStretchingTop, isStretchingLeft, isStretchingBottom, isStretchingRight);
 195
 196     if (layout.getDocument()->isSnapActive (true))
 197     {
 198         Component* const parent = target->getParentComponent();
 199         jassert (parent != 0);
 200
 201         if (parent != 0)
 202         {
 203             const int dx = parent->getX();
 204             const int dy = parent->getY();
 205
 206             int x = bounds.getX();
 207             int y = bounds.getY();
 208             int w = bounds.getWidth();
 209             int h = bounds.getHeight();
 210
 211             x += borderThickness - dx;
 212             y += borderThickness - dy;
 213             w -= borderThickness * 2;
 214             h -= borderThickness * 2;
 215
 216             int right = x + w;
 217             int bottom = y + h;
 218
 219             if (isStretchingRight)
 220                 right = layout.getDocument()->snapPosition (right);
 221
 222             if (isStretchingBottom)
 223                 bottom = layout.getDocument()->snapPosition (bottom);
 224
 225             if (isStretchingLeft)
 226                 x = layout.getDocument()->snapPosition (x);
 227
 228             if (isStretchingTop)
 229                 y = layout.getDocument()->snapPosition (y);
 230
 231             w = (right - x) + borderThickness * 2;
 232             h = (bottom - y) + borderThickness * 2;
 233             x -= borderThickness - dx;
 234             y -= borderThickness - dy;
 235
 236             bounds = Rectangle<int> (x, y, w, h);
 237         }
 238     }
 239 }
 240
 241 void ComponentOverlayComponent::applyBoundsToComponent (Component* component, const Rectangle<int>& bounds)
 242 {
 243     if (component->getBounds() != bounds)
 244     {
 245         layout.getDocument()->getUndoManager().undoCurrentTransactionOnly();
 246
 247         component->setBounds (bounds);
 248
 249         Component* const parent = target->getParentComponent();
 250         jassert (parent != 0);
 251
 252         if (parent != 0)
 253         {
 254             target->setBounds (bounds.getX() + borderThickness - parent->getX(),
 255                                bounds.getY() + borderThickness - parent->getY(),
 256                                bounds.getWidth() - borderThickness * 2,
 257                                bounds.getHeight() - borderThickness * 2);
 258         }
 259
 260         layout.updateStoredComponentPosition (target, true);
 261     }
 262 }
 263
 264 void ComponentOverlayComponent::showPopupMenu()
 265 {
 266     ComponentTypeHandler::getHandlerFor (*target)->showPopupMenu (target, layout);
 267 }